{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Network Variant Quantile Regression DQN (QR-DQN) implementation (PyTorch).\n",
    "\n",
    "In this notebook, we will implement QR-DQN variant of DQN carrying on from `listing5_5_dqn_pytorch.ipynb`. First part of the notebook is all about the vanilla DQN and how we train. The QR-DQN variant is after these sections carried over from previous notebook.\n",
    "\n",
    "\n",
    "In this notebook, we will implement QR-DQN variant of DQN. First part of the notebook is all about the vanilla DQN and how we train - a copy of `6_1_dqn_pytorch.ipynb`. The QR-DQN variant is after these sections on vanilla DQN.\n",
    "\n",
    "\n",
    "### RECAP\n",
    "\n",
    "\n",
    "$$ \n",
    "\\DeclareMathOperator*{\\max}{max}$$\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use ε-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update. \n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the q(s,a) for all the actions in the state `s`. It is denoted as $ \\hat{q}(s_t,a; w_{t}) $, where $w_{t}$ is the weights of the neural network which we are trying to learn as part of DQN learning. \n",
    "\n",
    "We use two networks, one target network to get the max q-value of next state denoted by $ \\max_a \\hat {q}(s_{t+1},a; w^{-}_{t}) $ and the primary network with weights $w_{t}$ which we are updated based on back propagation of the TD error through the network.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a,w^{-}_{t}) – \\hat{q}(S_t,A_t,w_t)] \\nabla \\hat{q}(S_t,A_t,w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values. \n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions (current state, action, reward, next state) in a buffer. Where each sample is denoted as a tuple: \n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s^{'}_{i}, done_{i})$$\n",
    "\n",
    "Subscript (i) denotes ith sample. We take N samples from experience replay selecting randomly and update the weights. Subscript (t) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "import gym\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "import math\n",
    "import os\n",
    "import io\n",
    "import base64\n",
    "import time\n",
    "from tqdm import trange\n",
    "import glob\n",
    "import random\n",
    "from collections import namedtuple\n",
    "\n",
    "from IPython.display import HTML, clear_output\n",
    "\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole and they try to run this on many other environments like Lunar Lander and others.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name, seed=None):\n",
    "    # remove time limit wrapper from environment\n",
    "    env = gym.make(env_name).unwrapped\n",
    "    if seed is not None:\n",
    "        env.seed(seed)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAScElEQVR4nO3db4xV953f8ffHGONo7Sq4jC3Cn5hm2ag46uLNiI3kqnUTurCutyQPUhGpEQ+QyAMixeoqrb0rdROpSNtqk1SRmkiktozSbAhS4jVK3e1imjQbyTXBXuyAMevZmJoJxIzJWrazKYHh2wdzWN/FM8xl/mT8m3m/pKt77vf8zj3fH4IPhx/nzk1VIUlqx3Vz3YAk6doY3JLUGINbkhpjcEtSYwxuSWqMwS1JjZm14E6yOcmJJENJ7p+t80jSQpPZuI87ySLgL4F/DgwDPwA+VlXPzfjJJGmBma0r7g3AUFX9qKp+AewFtszSuSRpQbl+lt53BXCq5/Uw8JsTDV62bFndfvvts9SKJLXn5MmTvPLKKxlv32wF93gn+ztrMkl2ADsAVq9ezeHDh2epFUlqz+Dg4IT7ZmupZBhY1fN6JXC6d0BV7a6qwaoaHBgYmKU2JGn+ma3g/gGwNsmaJDcAW4H9s3QuSVpQZmWppKouJvkk8D+BRcBDVXVsNs4lSQvNbK1xU1WPAY/N1vtL0kLlJyclqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEtSYwxuSWqMwS1JjTG4JakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDVmWl9dluQk8DowClysqsEktwDfAG4HTgL/qqr+enptSpIum4kr7n9WVeurarB7fT9wsKrWAge715KkGTIbSyVbgD3d9h7gw7NwDklasKYb3AX8WZKnkuzoardV1RmA7vnWaZ5DktRjWmvcwF1VdTrJrcCBJM/3e2AX9DsAVq9ePc02JGnhmNYVd1Wd7p7PAo8AG4CXkywH6J7PTnDs7qoarKrBgYGB6bQhSQvKlIM7ya8kufnyNvBbwFFgP7CtG7YNeHS6TUqS3jSdpZLbgEeSXH6fP66qP03yA2Bfku3AS8BHp9+mJOmyKQd3Vf0I+PVx6ueAD02nKUnSxPzkpCQ1xuCWpMYY3JLUGINbkhpjcEtSYwxuSWqMwS1JjTG4JakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktSYSYM7yUNJziY52lO7JcmBJC90z0t79j2QZCjJiSSbZqtxSVqo+rnifhjYfEXtfuBgVa0FDnavSbIO2Arc0R3zpSSLZqxbSdLkwV1V3wN+ekV5C7Cn294DfLinvreqzlfVi8AQsGFmWpUkwdTXuG+rqjMA3fOtXX0FcKpn3HBXe4skO5IcTnJ4ZGRkim1I0sIz0/85mXFqNd7AqtpdVYNVNTgwMDDDbUjS/DXV4H45yXKA7vlsVx8GVvWMWwmcnnp7kqQrTTW49wPbuu1twKM99a1JliRZA6wFDk2vRUlSr+snG5Dk68DdwLIkw8AfAH8I7EuyHXgJ+ChAVR1Lsg94DrgI7Kyq0VnqXZIWpEmDu6o+NsGuD00wfhewazpNSZIm5icnJakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1ZtLgTvJQkrNJjvbUPpPkx0mOdI97evY9kGQoyYkkm2arcUlaqPq54n4Y2DxO/QtVtb57PAaQZB2wFbijO+ZLSRbNVLOSpD6Cu6q+B/y0z/fbAuytqvNV9SIwBGyYRn+SpCtMZ437k0me7ZZSlna1FcCpnjHDXe0tkuxIcjjJ4ZGRkWm0IUkLy1SD+8vAe4D1wBngc10944yt8d6gqnZX1WBVDQ4MDEyxDUlaeKYU3FX1clWNVtUl4Cu8uRwyDKzqGboSOD29FiVJvaYU3EmW97z8CHD5jpP9wNYkS5KsAdYCh6bXoiSp1/WTDUjydeBuYFmSYeAPgLuTrGdsGeQk8AmAqjqWZB/wHHAR2FlVo7PSuSQtUJMGd1V9bJzyg1cZvwvYNZ2mJEkT85OTktQYg1uSGmNwS1JjDG5JaozBLUmNmfSuEmmhunj+b/ibV14CYMnfW8aSm5fNcUfSGINb6nHp4gVO/u89jJ7/2Vhwj5wEYPn7f4d3vf/euW1O6hjcUo+qS7x++gQXf/7aXLciTcg1bklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNmTS4k6xK8p0kx5McS/Kprn5LkgNJXuiel/Yc80CSoSQnkmyazQlI0kLTzxX3ReB3q+ofAh8AdiZZB9wPHKyqtcDB7jXdvq3AHcBm4EtJFs1G85K0EE0a3FV1pqqe7rZfB44DK4AtwJ5u2B7gw932FmBvVZ2vqheBIWDDDPctSQvWNa1xJ7kduBN4Eritqs7AWLgDt3bDVgCneg4b7mpXvteOJIeTHB4ZGZlC65K0MPUd3EluAr4J3FdVV/uZlxmnVm8pVO2uqsGqGhwYGOi3DUla8PoK7iSLGQvtr1XVt7ryy0mWd/uXA2e7+jCwqufwlcDpmWlXktTPXSUBHgSOV9Xne3btB7Z129uAR3vqW5MsSbIGWAscmrmWJWlh6+cbcO4CPg78MMmRrvZ7wB8C+5JsB14CPgpQVceS7AOeY+yOlJ1VNTrTjUvSQjVpcFfV9xl/3RrgQxMcswvYNY2+JEkT8JOTktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEtSYwxuSWqMwS1JjTG4JakxBrckNcbglqTGGNyS1BiDW5Ia08+XBa9K8p0kx5McS/Kprv6ZJD9OcqR73NNzzANJhpKcSLJpNicgSQtNP18WfBH43ap6OsnNwFNJDnT7vlBVf9Q7OMk6YCtwB/Au4PEkv+YXBkvSzJj0iruqzlTV093268BxYMVVDtkC7K2q81X1IjAEbJiJZiVJ17jGneR24E7gya70ySTPJnkoydKutgI41XPYMFcPeknSNeg7uJPcBHwTuK+qXgO+DLwHWA+cAT53eeg4h9c477cjyeEkh0dGRq61b0lasPoK7iSLGQvtr1XVtwCq6uWqGq2qS8BXeHM5ZBhY1XP4SuD0le9ZVburarCqBgcGBqYzB0laUPq5qyTAg8Dxqvp8T315z7CPAEe77f3A1iRLkqwB1gKHZq5lSVrY+rmr5C7g48APkxzpar8HfCzJesaWQU4CnwCoqmNJ9gHPMXZHyk7vKJGkmTNpcFfV9xl/3fqxqxyzC9g1jb4kSRPwk5OS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmN6efHukpNu3TpEvfddx+nTp2adOziRWHnP72Fm5Ys+jv1vXv38uf/4cG+zrdz5042btw4pV6lfhjcmveqiscff5zjx49POvbGG65n+29u5YbFS6ka+wfp9df9guPHj/Mn//3pvs537733TqtfaTIGt3SFv75wG0dGfocLtQSA5Te+yGgdnuOupDe5xi31GK3rOfLq3fy/SzcxWosZrcUM/3wt//dn6+a6NelvGdzSFUbrhisq4WItnpNepPH082XBNyY5lOSZJMeSfLar35LkQJIXuuelPcc8kGQoyYkkm2ZzAtJMCsWN171xRW2UGxf9bI46kt6qnyvu88AHq+rXgfXA5iQfAO4HDlbVWuBg95ok64CtwB3AZuBLSRaN98bS2811GeX9Sx/nlsVnuP7SK7zyykkWv/Edbr707Fy3Jv2tfr4suIDLlyCLu0cBW4C7u/oe4LvAv+vqe6vqPPBikiFgA/DEROe4cOECP/nJT6Y2A2kSly5dYnR0tK+xFy6O8pU/eZwlN3yXc6/9nD9/9iWgoKrv87322mv+fta0XbhwYcJ9fd1V0l0xPwX8KvBfqurJJLdV1RmAqjqT5NZu+Arg//QcPtzVJnTu3Dm++tWv9tOKdM2qildffbWvsaOXiseefGFa53viiSe4ePHitN5DOnfu3IT7+gruqhoF1id5J/BIkvddZXjGe4u3DEp2ADsAVq9ezac//el+WpGu2ejoKA8//DBnz579pZxv06ZNbN++/ZdyLs1f3/jGNybcd013lVTVq4wtiWwGXk6yHKB7vvynYhhY1XPYSuD0OO+1u6oGq2pwYGDgWtqQpAWtn7tKBrorbZK8A9gIPA/sB7Z1w7YBj3bb+4GtSZYkWQOsBQ7NcN+StGD1s1SyHNjTrXNfB+yrqm8neQLYl2Q78BLwUYCqOpZkH/AccBHY2S21SJJmQD93lTwL3DlO/RzwoQmO2QXsmnZ3kqS38JOTktQYg1uSGuNPB9S8l4SNGzfy3ve+95dyvne/+92/lPNo4TK4Ne9dd911fPGLX5zrNqQZ41KJJDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEtSYwxuSWpMP18WfGOSQ0meSXIsyWe7+meS/DjJke5xT88xDyQZSnIiyabZnIAkLTT9/Dzu88AHq+qNJIuB7yf5H92+L1TVH/UOTrIO2ArcAbwLeDzJr/mFwZI0Mya94q4xb3QvF3ePusohW4C9VXW+ql4EhoAN0+5UkgT0ucadZFGSI8BZ4EBVPdnt+mSSZ5M8lGRpV1sBnOo5fLirSZJmQF/BXVWjVbUeWAlsSPI+4MvAe4D1wBngc93wjPcWVxaS7EhyOMnhkZGRKbQuSQvTNd1VUlWvAt8FNlfVy12gXwK+wpvLIcPAqp7DVgKnx3mv3VU1WFWDAwMDU+ldkhakfu4qGUjyzm77HcBG4Pkky3uGfQQ42m3vB7YmWZJkDbAWODSjXUvSAtbPXSXLgT1JFjEW9Puq6ttJvppkPWPLICeBTwBU1bEk+4DngIvATu8okaSZM2lwV9WzwJ3j1D9+lWN2Abum15okaTx+clKSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEtSYwxuSWqMwS1JjTG4JakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDUmVTXXPZBkBPgZ8Mpc9zILluG8WjNf5+a82vLuqhoYb8fbIrgBkhyuqsG57mOmOa/2zNe5Oa/5w6USSWqMwS1JjXk7BffuuW5gljiv9szXuTmveeJts8YtSerP2+mKW5LUhzkP7iSbk5xIMpTk/rnu51oleSjJ2SRHe2q3JDmQ5IXueWnPvge6uZ5Ismluup5cklVJvpPkeJJjST7V1ZueW5IbkxxK8kw3r8929abndVmSRUn+Ism3u9fzZV4nk/wwyZEkh7vavJjblFTVnD2ARcBfAf8AuAF4Blg3lz1NYQ7/BPgN4GhP7T8B93fb9wP/sdte181xCbCmm/uiuZ7DBPNaDvxGt30z8Jdd/03PDQhwU7e9GHgS+EDr8+qZ378B/hj49nz5vdj1exJYdkVtXsxtKo+5vuLeAAxV1Y+q6hfAXmDLHPd0Tarqe8BPryhvAfZ023uAD/fU91bV+ap6ERhi7NfgbaeqzlTV093268BxYAWNz63GvNG9XNw9isbnBZBkJfAvgP/aU25+Xlcxn+d2VXMd3CuAUz2vh7ta626rqjMwFoDArV29yfkmuR24k7Gr0+bn1i0nHAHOAgeqal7MC/jPwL8FLvXU5sO8YOwv1z9L8lSSHV1tvsztml0/x+fPOLX5fJtLc/NNchPwTeC+qnotGW8KY0PHqb0t51ZVo8D6JO8EHknyvqsMb2JeSe4FzlbVU0nu7ueQcWpvu3n1uKuqTie5FTiQ5PmrjG1tbtdsrq+4h4FVPa9XAqfnqJeZ9HKS5QDd89mu3tR8kyxmLLS/VlXf6srzYm4AVfUq8F1gM+3P6y7gXyY5ydiS4weT/DfanxcAVXW6ez4LPMLY0se8mNtUzHVw/wBYm2RNkhuArcD+Oe5pJuwHtnXb24BHe+pbkyxJsgZYCxyag/4mlbFL6weB41X1+Z5dTc8tyUB3pU2SdwAbgedpfF5V9UBVrayq2xn7c/S/qupf0/i8AJL8SpKbL28DvwUcZR7Mbcrm+n9HgXsYu2Phr4Dfn+t+ptD/14EzwAXG/qbfDvx94CDwQvd8S8/43+/megL47bnu/yrz+seM/fPyWeBI97in9bkB/wj4i25eR4F/39WbntcVc7ybN+8qaX5ejN119kz3OHY5J+bD3Kb68JOTktSYuV4qkSRdI4NbkhpjcEtSYwxuSWqMwS1JjTG4JakxBrckNcbglqTG/H/KaIz0xWcldwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ENV_NAME = 'CartPole-v1'\n",
    "\n",
    "env = make_env(ENV_NAME)\n",
    "env.reset()\n",
    "plt.imshow(env.render(\"rgb_array\"))\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network using pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us build a DQN agent using a simple network. We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden payers with Relu activation and final layer being logits with dimension equation to number of actions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (inout is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.fc1 = nn.Linear(state_dim, 64)\n",
    "        self.fc2 = nn.Linear(64, 128)\n",
    "        self.fc3 = nn.Linear(128, 32)\n",
    "        self.q = nn.Linear(32, n_actions)\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the newrok to get Q(s,a)\n",
    "        x = F.relu(self.fc1(state_t))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        qvalues = self.q(x)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and outout is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s = env.reset()\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, done, _ = env.step(action)\n",
    "            reward += r\n",
    "            if done:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.0\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy (epsilon greedy) to sample from the environment and store the transitions (s,a,r,s',done) into a buffer. These samples are used multiple times in a learning making the process sample efficient. \n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "We have modified the implementation a bit to make it more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]        \n",
    "        next_s, r, done, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s = env.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "        \n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Target network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with... Q-learning\n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation: \n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right]^2$$\n",
    "\n",
    "\n",
    "$$ \\nabla_w L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',A;w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network. \n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i +  \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t})$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$ \n",
    "\\DeclareMathOperator*{\\max}{max} w_{t+1} \\leftarrow w_t - \\alpha \\nabla_{w}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def td_loss_dqn(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    q_s = agent(states)\n",
    "\n",
    "    # select q-values for chosen actions\n",
    "    q_s_a = q_s[range(\n",
    "        len(actions)), actions]\n",
    "\n",
    "    with torch.no_grad():\n",
    "        # compute q-values for all actions in next states\n",
    "        # use target network\n",
    "        q_s1 = target_network(next_states)\n",
    "\n",
    "\n",
    "        # compute Qmax(next_states, actions) using predicted next q-values\n",
    "        q_s1_a1max,_ = torch.max(q_s1, dim=1)\n",
    "\n",
    "        # compute \"target q-values\" \n",
    "        target_q = rewards + gamma * q_s1_a1max * (1-done_flags)\n",
    "\n",
    "    # mean squared error loss to minimize\n",
    "    loss = torch.mean((q_s_a - target_q.detach()) ** 2)\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main loop\n",
    "\n",
    "We now carryout the training on DQN setup above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_agent(env, agent, target_network, optimizer, td_loss_fn):\n",
    "    \n",
    "    state = env.reset()\n",
    "    # let us fill experience replay with some samples using full random policy\n",
    "    exp_replay = ReplayBuffer(10**4)\n",
    "    for i in range(100):\n",
    "        play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "        if len(exp_replay) == 10**4:\n",
    "            break\n",
    "    print('Finished filling buffer with: {} samples'.format(len(exp_replay)))\n",
    "\n",
    "    mean_rw_history = []\n",
    "    td_loss_history = []\n",
    "    state = env.reset()\n",
    "    for step in trange(total_steps + 1):\n",
    "\n",
    "        # reduce exploration as we progress\n",
    "        agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "        # take timesteps_per_epoch and update experience replay buffer\n",
    "        _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "        # train by sampling batch_size of data from experience replay\n",
    "        states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "\n",
    "\n",
    "        # loss = <compute TD loss>\n",
    "        optimizer.zero_grad()\n",
    "        loss = td_loss_fn(agent, target_network, \n",
    "                          states, actions, rewards, next_states, done_flags,                  \n",
    "                          gamma=0.99,\n",
    "                          device=device)\n",
    "\n",
    "        loss.backward()\n",
    "        grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "        optimizer.step()\n",
    "\n",
    "        if step % loss_freq == 0:\n",
    "            td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "        if step % refresh_target_network_freq == 0:\n",
    "            # Load agent weights into target_network\n",
    "            target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "        if step % eval_freq == 0:\n",
    "            # eval the agent\n",
    "            mean_rw_history.append(evaluate(\n",
    "                make_env(ENV_NAME, seed=step), agent, n_games=3, greedy=True, t_max=1000)\n",
    "            )\n",
    "\n",
    "            clear_output(True)\n",
    "            print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "                  (len(exp_replay), agent.epsilon))\n",
    "\n",
    "            plt.figure(figsize=[16, 5])\n",
    "            plt.subplot(1, 2, 1)\n",
    "            plt.title(\"Mean reward per episode\")\n",
    "            plt.plot(mean_rw_history)\n",
    "            plt.grid()\n",
    "\n",
    "            assert not np.isnan(td_loss_history[-1])\n",
    "            plt.subplot(1, 2, 2)\n",
    "            plt.title(\"TD loss history (smoothened)\")\n",
    "            plt.plot(smoothen(td_loss_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 3 * 10**4\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup spme frequency for loggind and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000\n",
    "\n",
    "#set up random numbers\n",
    "seed=0\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "ENV_NAME = 'CartPole-v1'\n",
    "env = make_env(ENV_NAME, seed)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 30001/30001 [03:30<00:00, 142.67it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent(env, agent, target_network, optimizer, td_loss_fn=td_loss_dqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 283\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(ENV_NAME),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score: {:.0f}'.format(final_score))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_animation(env, agent, save_dir):\n",
    "    \n",
    "    try:\n",
    "        env = gym.wrappers.Monitor(\n",
    "            env, save_dir, video_callable=lambda id: True, force=True, mode='evaluation')\n",
    "    except gym.error.Error as e:\n",
    "        print(e)\n",
    "\n",
    "    if not os.path.exists(save_dir):\n",
    "        os.makedirs(save_dir)\n",
    "        \n",
    "    state = env.reset()\n",
    "    reward = 0\n",
    "    while True:\n",
    "        qvalues = agent.get_qvalues([state])\n",
    "        action = qvalues.argmax(axis=-1)[0]\n",
    "        state, r, done, _ = env.step(action)\n",
    "        reward += r\n",
    "        if done:\n",
    "            print('Got reward: {}'.format(reward))\n",
    "            break\n",
    "            \n",
    "def display_animation(filepath):\n",
    "    video = io.open(filepath, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    return HTML(data='''<video alt=\"test\" controls>\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "                 </video>'''.format(encoded.decode('ascii')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got reward: 355.0\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Animate learned policy\n",
    "save_dir='./videos/pytorch/6_8/'\n",
    "env = make_env(ENV_NAME)\n",
    "generate_animation(env, agent, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quantile Regression (QR-DQN)\n",
    "\n",
    "Similar to C51 approach of distributional RL, the QR-DQN approach also depended on using quantiles to predict the distribution of Q(s,a) instead of predicting an estimate of the average of Q(s,a). PLease refer paper https://arxiv.org/pdf/1710.10044.pdf for more details. Both C51 and QR-DQN are variants of distributional RL and produced by scientists from DeepMind. \n",
    "\n",
    "The C51 approach modeled the distribution of $Q^{\\pi}(s,a)$ named $Z^{\\pi}(s,a)$ as a categorical distribution of probability over fixed points in the range of $V_{min}$ to $V_{max}$. The probability over these points was what was learnt by the network. Such an approached resulted in use of a projection step after bellman update to bring the new probabilities back to the fixed support points of `n_atoms` spread uniformly over $V_{min}$ to $V_{max}$. While the result worked there was a bit of disconnect with the theoretical basis on which the algorithm was derived.\n",
    "\n",
    "In contrast, in QR-DQN the approach was slightly different. The support points are still `N` but now the probabilities were fixed to 1/N with the location of these points something being learnt by network. In the words of authors....\n",
    "\n",
    ">We “transpose” the parametrization from C51: whereas the former uses N fixed locations for its approximation distribution and adjusts their probabilities, we assign fixed, uniform probabilities to N adjustable locations\n",
    "\n",
    "\n",
    "The loss used in this approach is that of quantile regression loss mixed with huber loss called **Quantile Huber loss** - equation 9 and 10 in the linked paper.\n",
    "\n",
    "Code cells below give an implementation of QR-DQN. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QRDQN(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, N=51, epsilon=0):\n",
    "\n",
    "        super(QRDQN, self).__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        self.N = N\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (inout is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.fc1 = nn.Linear(state_dim, 64)\n",
    "        self.fc2 = nn.Linear(64, 128)\n",
    "        self.fc3 = nn.Linear(128, 32)\n",
    "        self.q = nn.Linear(32, n_actions*N)\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the newrok to get Q(s,a)\n",
    "        x = F.relu(self.fc1(state_t))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        qvalues = self.q(x)\n",
    "        qvalues= qvalues.view(-1, self.n_actions, self.N)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and outout is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions, N = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.mean(-1).argmax(-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss_qr_dqn(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)   #(batch_size, state_dim)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)  #(batch_size,)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float) #(batch_size,)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float) #(batch_size, state_dim)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float) #(batch_size,)\n",
    "        \n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    q_s = agent(states)  #(batch_size, n_actions, N)\n",
    "    batch_size, n_actions, N = q_s.shape\n",
    "    \n",
    "    tau = torch.FloatTensor([i/N for i in range(1,N+1)]).to(device) #(N,)\n",
    "    \n",
    "    # select q-values for chosen actions\n",
    "    q_s_a = q_s.gather(1, actions.unsqueeze(1).unsqueeze(1).expand(batch_size, 1, N)) #(batch_size, 1, N)\n",
    "    # print(q_s_a.shape)\n",
    "    #q_s_a = q_s_a.expand(batch_size, N, N) #(batch_size, N, N)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        # compute q-values for all actions in next states\n",
    "        # use target network\n",
    "        q_s1 = target_network(next_states)  #(batch_size, n_actions, N)\n",
    "\n",
    "        # compute Qmax(next_states, actions) using predicted next q-values\n",
    "        s1_actions_max = torch.argmax(q_s1.mean(-1), dim=-1) #(batch_size,)\n",
    "        q_s1_amax = q_s1.gather(1, s1_actions_max.unsqueeze(1).unsqueeze(1).expand(batch_size, 1, N)) #(batch_size, 1, N)\n",
    "        q_s1_amax = q_s1_amax.transpose(1,2) #(batch_size, N, 1)\n",
    "\n",
    "        rewards = rewards.unsqueeze(-1).unsqueeze(-1).expand(batch_size, N, 1) #(batch_size, N, 1)\n",
    "        done_flags = done_flags.unsqueeze(-1).unsqueeze(-1).expand(batch_size, N, 1) #(batch_size, N, 1)\n",
    "\n",
    "        targets = rewards + gamma * (1-done_flags) * q_s1_amax  # (batch_size, N, 1)\n",
    "        # print(targets.shape)\n",
    "        #targets = targets.expand(batch_size, N, 1) # (batch_size, N, N) \n",
    "        \n",
    "    td_errors = targets.detach() - q_s_a # (batch_size, N, N)\n",
    "        \n",
    "    k = 1.0 #kappa fixed at 1.0\n",
    "    \n",
    "    huber_loss = torch.where(td_errors.abs() <= k, 0.5*td_errors.pow(2), k*(td_errors.abs()-0.5*k)) # (batch_size, N, N)\n",
    "    quantile_loss = torch.abs(tau - (td_errors.detach() < 0).float()) * huber_loss # (batch_size, N, N)\n",
    "                            \n",
    "    # loss to minimize as per paper https://arxiv.org/pdf/1710.10044.pdf equation Algorithm 1 and eq 10\n",
    "    loss = quantile_loss.sum(-1).mean(-1).mean()\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_qr_dqn(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s = env.reset()\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.mean(-1).argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, done, _ = env.step(action)\n",
    "            reward += r\n",
    "            if done:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_agent_qr_dqn(env, agent, target_network, optimizer, td_loss_fn):\n",
    "    \n",
    "    state = env.reset()\n",
    "    # let us fill experience replay with some samples using full random policy\n",
    "    exp_replay = ReplayBuffer(10**4)\n",
    "    for i in range(100):\n",
    "        play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "        if len(exp_replay) == 10**4:\n",
    "            break\n",
    "    print('Finished filling buffer with: {} samples'.format(len(exp_replay)))\n",
    "\n",
    "    mean_rw_history = []\n",
    "    td_loss_history = []\n",
    "    state = env.reset()\n",
    "    for step in trange(total_steps + 1):\n",
    "\n",
    "        # reduce exploration as we progress\n",
    "        agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "        # take timesteps_per_epoch and update experience replay buffer\n",
    "        _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "        # train by sampling batch_size of data from experience replay\n",
    "        states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "\n",
    "\n",
    "        # loss = <compute TD loss>\n",
    "        optimizer.zero_grad()\n",
    "        loss = td_loss_fn(agent, target_network, \n",
    "                          states, actions, rewards, next_states, done_flags,                  \n",
    "                          gamma=0.99,\n",
    "                          device=device)\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        if step % loss_freq == 0:\n",
    "            td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "        if step % refresh_target_network_freq == 0:\n",
    "            # Load agent weights into target_network\n",
    "#             target_network.load_state_dict(agent.state_dict())\n",
    "            for target_param, agent_param in zip(target_network.parameters(), agent.parameters()):\n",
    "                target_param.data.copy_(0.001*agent_param.data + (1.0-0.001)*target_param.data)\n",
    "\n",
    "        if step % eval_freq == 0:\n",
    "            # eval the agent\n",
    "            mean_rw_history.append(evaluate_qr_dqn(\n",
    "                make_env(ENV_NAME, seed=step), agent, n_games=3, greedy=True, t_max=1000)\n",
    "            )\n",
    "\n",
    "            clear_output(True)\n",
    "            print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "                  (len(exp_replay), agent.epsilon))\n",
    "\n",
    "            plt.figure(figsize=[16, 5])\n",
    "            plt.subplot(1, 2, 1)\n",
    "            plt.title(\"Mean reward per episode\")\n",
    "            plt.plot(mean_rw_history)\n",
    "            plt.grid()\n",
    "\n",
    "            assert not np.isnan(td_loss_history[-1])\n",
    "            plt.subplot(1, 2, 2)\n",
    "            plt.title(\"TD loss history (smoothened)\")\n",
    "            plt.plot(smoothen(td_loss_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 2 * 10**4\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup spme frequency for loggind and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 1\n",
    "eval_freq = 1000\n",
    "\n",
    "#set up random numbers\n",
    "seed=0\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "ENV_NAME = 'CartPole-v1'\n",
    "env = make_env(ENV_NAME, seed)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = QRDQN(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = QRDQN(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 20001/20001 [03:45<00:00, 88.75it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent_qr_dqn(env, agent, target_network, optimizer, td_loss_fn=loss_qr_dqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 289\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate_qr_dqn(\n",
    "  make_env(ENV_NAME),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score: {:.0f}'.format(final_score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DQN agent with experience replay and target networks. We also saw 2nd variant of distributional RL called **Distributional RL - Quantile Regression DQN (QR-DQN)**\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
